/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package Toepen.SpelFacade;

import java.io.Serializable;
import java.util.EnumMap;
import java.util.HashMap;
import java.util.List;
import toepen.Kaart;
import toepen.Kleur;
import toepen.Waarde;

/**
 * Facadeversie van Kaart uit het domeinmodel, met conversiefuncties
 * @author Bart Piggen
 */
public class FacadeKaart implements Serializable {
    private FacadeKleur _Kleur;
    private FacadeWaarde _Waarde;

    /**
     * Constructor voor FacadeKaart
     * @param kleur van de kaart
     * @param waarde van de kaart
     */
    protected FacadeKaart(FacadeKleur kleur, FacadeWaarde waarde)
    {
        _Kleur=kleur;
        _Waarde=waarde;
    }

    /**
     * @return de kleur
     */
    public FacadeKleur getKleur()
    {
        return(_Kleur);
    }

    /**
     * @return de waarde
     */
    public FacadeWaarde getWaarde()
    {
        return(_Waarde);
    }

    @Override
    public String toString() {
        return(_Kleur.toString() + ": " + _Waarde.toString());
    }

    private static HashMap<Kleur, FacadeKleur> kleurenToFacade;
    private static HashMap<Waarde, FacadeWaarde> waardesToFacade;
    private static HashMap<FacadeKleur, Kleur> facadeToKleuren;
    private static HashMap<FacadeWaarde, Waarde> facadeToWaardes;

    /**
     * Zet een domeinmodel Kaart om in een FacadeKaart
     * @param kaart die omgezet moet worden
     * @return FacadeKaart die er van gemaakt is
     */
    protected static FacadeKaart fromKaart(Kaart kaart)
    {
        if(kleurenToFacade==null) {
            initHashMaps();
        }

        return(new FacadeKaart(kleurenToFacade.get(kaart.getKleur()),waardesToFacade.get(kaart.getWaarde())));
    }

    /**
     * Maakt van een FacadeKaart een Kaart voor het domeinmodel
     * @param kaart die omgezet moet worden
     * @return kaart voor het domeinmodel
     */
    protected static Kaart toKaart(FacadeKaart kaart)
    {
        if(kleurenToFacade==null) {
            initHashMaps();
        }

        return(new Kaart(facadeToKleuren.get(kaart.getKleur()),facadeToWaardes.get(kaart.getWaarde())));
    }

    /**
     * Zet meerdere kaarten uit het domeinmodel om in facadekaarten
     * @param kaarten die omgezet moet worden
     * @return array van FacadeKaarten
     */
    protected static FacadeKaart[] fromKaarten(List<Kaart> kaarten)
    {
        FacadeKaart[] retVal=new FacadeKaart[kaarten.size()];
        for(int i=0;i<kaarten.size();i++)
            retVal[i]=fromKaart(kaarten.get(i));

        return(retVal);
    }

    /**
     * Initialiseren van de hashmaps voor het omzetten
     */
    private static void initHashMaps()
    {
        kleurenToFacade=new HashMap<Kleur, FacadeKleur>();
        kleurenToFacade.put(Kleur.HARTEN, FacadeKleur.HARTEN);
        kleurenToFacade.put(Kleur.KLAVEREN, FacadeKleur.KLAVEREN);
        kleurenToFacade.put(Kleur.RUITEN, FacadeKleur.RUITEN);
        kleurenToFacade.put(Kleur.SCHOPPEN, FacadeKleur.SCHOPPEN);

        facadeToKleuren=new HashMap<FacadeKleur, Kleur>();
        facadeToKleuren.put(FacadeKleur.HARTEN, Kleur.HARTEN);
        facadeToKleuren.put(FacadeKleur.KLAVEREN, Kleur.KLAVEREN);
        facadeToKleuren.put(FacadeKleur.RUITEN, Kleur.RUITEN);
        facadeToKleuren.put(FacadeKleur.SCHOPPEN, Kleur.SCHOPPEN);

        waardesToFacade=new HashMap<Waarde, FacadeWaarde>();
        waardesToFacade.put(Waarde.AAS, FacadeWaarde.AAS);
        waardesToFacade.put(Waarde.ACHT, FacadeWaarde.ACHT);
        waardesToFacade.put(Waarde.BOER, FacadeWaarde.BOER);
        waardesToFacade.put(Waarde.HEER, FacadeWaarde.HEER);
        waardesToFacade.put(Waarde.HEER, FacadeWaarde.HEER);
        waardesToFacade.put(Waarde.NEGEN, FacadeWaarde.NEGEN);
        waardesToFacade.put(Waarde.TIEN, FacadeWaarde.TIEN);
        waardesToFacade.put(Waarde.VROUW, FacadeWaarde.VROUW);
        waardesToFacade.put(Waarde.ZEVEN, FacadeWaarde.ZEVEN);

        facadeToWaardes=new HashMap<FacadeWaarde, Waarde>();
        facadeToWaardes.put(FacadeWaarde.AAS, Waarde.AAS);
        facadeToWaardes.put(FacadeWaarde.ACHT, Waarde.ACHT);
        facadeToWaardes.put(FacadeWaarde.BOER, Waarde.BOER);
        facadeToWaardes.put(FacadeWaarde.HEER, Waarde.HEER);
        facadeToWaardes.put(FacadeWaarde.HEER, Waarde.HEER);
        facadeToWaardes.put(FacadeWaarde.NEGEN, Waarde.NEGEN);
        facadeToWaardes.put(FacadeWaarde.TIEN, Waarde.TIEN);
        facadeToWaardes.put(FacadeWaarde.VROUW, Waarde.VROUW);
        facadeToWaardes.put(FacadeWaarde.ZEVEN, Waarde.ZEVEN);
    }
}
